import java.util.Arrays;

public class TestDemo {
    public static void move(char pos1, char pos2){
        System.out.print(pos1+" -> "+pos2+" ");
    }

    /**
     *
     * @param n 代表盘子的个数
     * @param pos1  盘子所在的起始位置
     * @param pos2  盘子的中转位置
     * @param pos3  盘子的结束位置
     */
    public static void hanio(int n, char pos1, char pos2, char pos3){
        if(n == 1){
            move(pos1,pos3);
        }else {
            hanio(n-1,pos1,pos3,pos2);
            move(pos1,pos3);
            hanio(n-1, pos2, pos1,pos3);
        }
    }
    // 1 汉诺塔问题
    public static void main1(String[] args) {
        hanio(1,'A','B','C');
        System.out.println();
        hanio(2,'A','B','C');
        System.out.println();
        hanio(3,'A','B','C');
        System.out.println();
    }

    //数组
    public static void main2(String[] args) {
        //数组定义
        int[] arr1 = {1, 2, 3};
        int[] arr2 = new int[3];
        int[] arr3 = new int[]{1, 2, 3};
    }

    public static void main3(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(arr.length); //求数组长度
        System.out.println(arr[2]); //查询某一个数组元素
        arr[2] = 20;    //更改数组元素
        System.out.println(arr[2]);
    }

    //数组的打印方式
    public static void main4(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        //打印数组内容方法1：
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] +" ");
        }
        System.out.println();

        //打印数组内容方法2：for each循环（增强for循环）
        /*
        for循环：可以得到下标
        for each循环：不可以得到下标，适合于集合操作
         */
        for (int x : arr){
            System.out.print(x + " ");
        }
        System.out.println();

        //借助java的操作数组的工具类Arrays.toString--将参数的数组 以字符串的形式输出
        /*String ret = Arrays.toString(arr);
        System.out.println(ret);*/
        System.out.println(Arrays.toString(arr));
    }

    //数组作为方法的参数
    public static void print(int[] arr){
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static void main5(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        print(arr); //按引用传参，也是按值传参
    }

    public static void func1(int[] arr){
        //虽然这里传的是地址，但是传过去之后，形参只是改变了自己的指向
        arr = new int[]{11,22,33,44};
    }
    public static void func2(int[] arr){
        arr[0] = 999;
    }

    public static void main6(String[] args) {
        int[] arr = {1,2,3,4,5};
        System.out.println(Arrays.toString(arr));   //打印的依旧是实参的arr

        func1(arr);
        System.out.println(Arrays.toString(arr)); //[1, 2, 3, 4, 5]
        func2(arr);
        System.out.println(Arrays.toString(arr)); //[999, 2, 3, 4, 5]
    }

    /**
     * 在原来数组基础上扩大二倍
     * @param arr
     */
    public static void fun(int[] arr){
        for (int i = 0; i < arr.length; i++){
            arr[i] = 2 * arr[i];
        }
    }
    //数组作为返回值
    public static int[] transform(int[] arr){
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = 2 * arr[i];
        }
        return ret;
    }
    public static void main7(String[] args) {
        int[] arr = {1,2,3,4,5};
        fun(arr);
        System.out.println(Arrays.toString(arr));

        int[] ret = transform(arr);
        System.out.println(Arrays.toString(ret));
    }

    //模拟实现myToString
    public static void main8(String[] args) {
        int[] arr = {1,2,3,4,5};
        System.out.println(myToString(arr));
    }
    public static String myToString(int[] arr){
        if(arr == null) return null;
        String str = "[";
        for(int i = 0; i < arr.length; i++){
            if(i < arr.length - 1){
                str = str + arr[i] + ",";
            }else {
                str = str + arr[i];
            }
        }
        str += "]";
        return str;
    } //结果：[1,2,3,4,5]

    //找最大值
    public static int maxNum(int[] arr){
        if(arr == null) return -1;
        if(arr.length == 0) return -1;
        int max = arr[0];
        for (int i = 0; i < arr.length; i++){
            if(max < arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
    public static void main9(String[] args) {
        int[] arr = {12,3,555,60};
        System.out.println(maxNum(arr));;
    }

    public static boolean isUp(int[] arr){
        for (int i = 0; i < arr.length - 1; i++){
            if(arr[i] < arr[i+1]){
                return false;
            }
        }
        return true;
    }
    //判断数组元素是否升序
    public static void main10(String[] args) {
        int[] arr = {11,22,33,4,55};
        boolean flag = isUp(arr);
        System.out.println(flag);
    }

    //冒泡排序
    public static void bubbleSort(int[] arr){
        //i表示趟数
        for(int i = 0; i < arr.length-1; i++){
            boolean flag = false;   //对每一趟都进行检查是否进行了排序
            for(int j = 0; j < arr.length-1-i; j++){
                if(arr[j] > arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                    flag = true;
                }
            }
            if(flag == false){
                break;  //表示没有进行排序，则后续都不用排序了，已经是升序排序了。
            }
        }
    }
    //逆置数组元素
    public static void reverse(int[] arr){
        int i = 0;
        int j = arr.length-1;
        while (i < j){
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    }
    //偶数位于奇数的前边
    public static void evenOdd(int[] arr){
        int i = 0;
        int j = arr.length-1;
        while (i < j){
            while (i < j && arr[i] % 2 == 0){
                i++;
            }//如果循环退出则表示i下标一定是奇数
            while (i < j && arr[j] % 2 != 0){
                j--;
            }//如果循环退出则表示j下标一定是偶数
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }
    //拷贝数组
    public static int[] copyArr(int[] arr){
        int[] copy = new int[arr.length];
        for (int i = 0; i < arr.length; i++){
            copy[i] = arr[i];
        }
        return copy;
    }
    public static void main11(String[] args) {
        int[] arr = {3,4,5,6,7};
        int[] ret = copyArr(arr);
        System.out.println(Arrays.toString(ret));

        //相当于对数组扩容
        int[] ret2 = Arrays.copyOf(arr,arr.length*2);
        System.out.println(Arrays.toString(ret2));

        int[] ret3 = Arrays.copyOfRange(arr,1,3); //拷贝局部
        System.out.println(Arrays.toString(ret3));

        int[] copy = new int[arr.length];
        System.arraycopy(arr,0,copy,0,arr.length);
        System.out.println(Arrays.toString(copy));

        //直接克隆数组拷贝
        int[] copy2 = arr.clone();  //产生一个副本（copy2）
        System.out.println(Arrays.toString(copy2));

/*        int[] arr = {11,23,9,6,22};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));*/

        /*int[] arr = {1,2,3,4,5};
        reverse(arr);
        System.out.println(Arrays.toString(arr));*/

        /*int[] arr = {1,2,3,4,5};
        evenOdd(arr);
        System.out.println(Arrays.toString(arr));*/
    }

    //二维数组
    public static void main12(String[] args) {
//        int[][] arr = {{1,2,3},{4,5,6}};
        int[][] arr = new int[2][];
        arr[0] = new int[2];
        arr[1] = new int[3];
        for (int i = 0; i < arr.length; i++){
            for(int j = 0; j < arr[i].length; j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
       /* System.out.println();
        for (int[] ret : arr){
            for (int x : ret){
                System.out.print(x +" ");
            }
        }
        System.out.println();
        System.out.println(Arrays.deepToString(arr));*/
    }

//    创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
    public static void main(String[] args) {
        int[] arr = new int[100];
        for (int i = 0; i < arr.length; i++){
            arr[i] = i + 1;
        }
        System.out.println(Arrays.toString(arr));
    }
}
